Hvordan endrer du eksisterende, ikke-pushede meldinger?

Endring av den siste meldingen
git commit --endre
åpner redaktøren din, slik at du kan endre kommisjonsmeldingen til den siste kommisjonen. I tillegg kan du stille kommittemeldingen direkte i kommandolinjen med:
git commit --amend -m "New commit message"
... dette kan imidlertid gjøre flere linjer forpliktingsmeldinger eller små rettelser vanskeligere å legge inn.
Forsikre deg om at du ikke har endret noen endringer i arbeidskopien før du gjør dette, ellers blir de også engasjert. (Ustadierte endringer blir ikke forpliktet.)
Endre meldingen om en forpliktelse som du allerede har sendt til den eksterne grenen
Hvis du allerede har presset oppdraget ditt til den eksterne grenen din, må du - etter endring av forpliktelsen lokalt (som beskrevet ovenfor) - også tvinge presse forpliktelsen med:
git push   --force
# Eller
git push   -f
Advarsel: tvangstrykk vil overskrive den eksterne grenen med tilstanden til din lokale. Hvis det er forpliktelser på den eksterne grenen du ikke har i din lokale filial, mister du disse forpliktelsene.
Advarsel: vær forsiktig med å endre forpliktelser som du allerede har delt med andre mennesker. Endring forplikter seg i hovedsak til å omskrive dem til å ha forskjellige SHA-IDer, noe som utgjør et problem hvis andre har kopier av det gamle forpliktelsen du har skrevet om. Alle som har en kopi av den gamle forpliktelsen, må synkronisere arbeidet sitt med det nylig omskrevne forpliktelsen, noe som noen ganger kan være vanskelig, så sørg for at du koordinerer med andre når du prøver å omskrive delt forpliktelseshistorikk, eller bare unngå å skrive om delte forpliktelser helt.
Utfør en interaktiv rebase
Et annet alternativ er å bruke interaktiv rebase.
Dette lar deg redigere meldinger du vil oppdatere, selv om det ikke er den siste meldingen.
For å gjøre en Git squash, følg disse trinnene:
// n er antall forpliktelser opp til den siste forpliktelsen du vil kunne redigere
git rebase -i HEAD ~ n
Når du klemmer forpliktelsene dine - velg e / r for redigering av meldingen:
Viktig merknad om interaktiv rebase
Når du bruker git rebase -i HEAD ~ n, kan det være mer enn n forpliktelser. Git vil "samle" alle forpliktelsene i de siste n forpliktelsene, og hvis det var en sammenslåing et sted mellom det området, vil du også se alle forpliktelsene, så resultatet blir n +.
Godt tips:
Hvis du må gjøre det i mer enn en enkelt gren, og du kan møte konflikter når du endrer innholdet, kan du konfigurere git rerere og la Git løse disse konfliktene automatisk for deg.
Dokumentasjon
git-commit (1) Manuell side
git-rebase (1) Manuell side
git-push (1) Manuell side
|
git commit --end -m "din nye melding"
|
Hvis forpliktelsen du vil fikse, ikke er den siste:
git rebase - interaktiv $ parent_of_flawed_commit
Hvis du vil fikse flere mangelfulle forpliktelser, passerer du foreldrene til den eldste av dem.
En redaktør vil komme opp, med en liste over alle forpliktelser siden den du ga.
Endre valg for å omformulere (eller på gamle versjoner av Git, for å redigere) foran eventuelle forpliktelser du vil fikse.
Når du har lagret, vil Git spille de listede forpliktelsene på nytt.
For hver forpliktelse du vil omformulere, vil Git slippe deg tilbake til redaktøren din. For hver forpliktelse du vil redigere, slipper Git deg i skallet. Hvis du er i skallet:
Endre forpliktelsen på den måten du vil.
git commit --endre
git rebase - fortsett
Det meste av denne sekvensen vil bli forklart for deg ved å sende ut de forskjellige kommandoene mens du går. Det er veldig lett; du trenger ikke å huske det - bare husk at git rebase --interactive lar deg rette forpliktelser uansett hvor lenge siden de var.
Merk at du ikke vil endre forpliktelser som du allerede har presset. Eller kanskje du gjør det, men i så fall må du være veldig forsiktig med å kommunisere med alle som kanskje har trukket forpliktelsene dine og gjort arbeidet på toppen av dem. Hvordan kan jeg gjenopprette / resynkronisere etter at noen presser en rebase eller en tilbakestilling til en publisert gren?
|
For å endre den forrige forpliktelsen, gjør du endringene du ønsker og trinnvis endringene, og kjør deretter
git commit --endre
Dette åpner en fil i tekstredigeringsprogrammet som representerer den nye meldingsmeldingen. Det begynner å være fylt med teksten fra den gamle forpliktelsesmeldingen. Endre kommittemeldingen som du vil, lagre filen og avslutt redigeringsprogrammet for å fullføre.
For å endre forrige forpliktelse og beholde den samme loggmeldingen, kjør
git commit --end -C HEAD
For å fikse forrige forpliktelse ved å fjerne den helt, kjør
git reset --hard HEAD ^
Hvis du vil redigere mer enn én kommandomelding, kjører du
git rebase -i HEAD ~ commit_count
(Erstatt commit_count med antall forpliktelser du vil redigere.) Denne kommandoen starter redaktøren. Merk den første forpliktelsen (den du vil endre) som “rediger” i stedet for “velg”, og lagre og avslutter deretter redaktøren. Gjør endringen du vil begå, og kjør deretter
git commit --endre
git rebase - fortsett
Merk: Du kan også "Gjør den endringen du ønsker" fra redaktøren åpnet av git commit --amend
|
Som alleredenevnt, git commit - endring er måten å overskrive den siste forpliktelsen på. En merknad: Hvis du også vil overskrive filene, vil kommandoen være
git commit -a --amend -m "My new commit message"
|
Du kan også bruke git filtergren for det.
git filter-branch -f --msg-filter "sed 's / errror / error /'" $ flawed_commit..HEAD
Det er ikke så enkelt som en triviell git-forpliktelse - endre, men det er spesielt nyttig hvis du allerede har noen sammenslåinger etter den feilaktige forpliktelsesmeldingen.
Merk at dette vil prøve å skrive om hver forpliktelse mellom HEAD og feilforpliktelsen, så du bør velge msg-filter-kommandoen veldig klokt ;-)
|
Jeg foretrekker denne måten:
git commit --amend -c 
Ellers vil det være en ny forpliktelse med en ny forpliktelses-ID.
|
Hvis du bruker Git GUI-verktøyet, er det en knapp som heter Endre siste kommisjon. Klikk på den knappen, og deretter vil den vise de siste kommisjonsfilene og meldingen. Bare rediger den meldingen, så kan du begå den med en ny meldingsmelding.
Eller bruk denne kommandoen fra en konsoll / terminal:
git commit -a --amend -m "My new commit message"
|
Du kan bruke Git rebasing. Hvis du for eksempel vil endre tilbake for å begå bbc643cd, kjører du
$ git rebase bbc643cd ^ --interaktiv
I standardredigeringsprogrammet endrer du 'velg' til 'rediger' på linjen hvis forpliktelse du vil endre. Gjør endringene dine og deretter iscenesett dem med
$ git legg til 
Nå kan du bruke
$ git commit --end
for å endre forpliktelsen, og etter det
$ git rebase - fortsett
for å gå tilbake til forrige hodeforpliktelse.
|
Hvis du bare vil endre den siste forpliktelsesmeldingen din, gjør du så:
git commit --endre
Dette vil føre deg til teksteditoren din og la deg endre den siste meldingen.
Hvis du vil endre de tre siste kommisjonsmeldingene, eller noen av kommisjonsmeldingene fram til det tidspunktet, må du levere HEAD ~ 3 til kommandoen git rebase -i:
git rebase -i HEAD ~ 3
|
Hvis du må endre en gammel kommisjonsmelding over flere grener (dvs. kommisjonen med feilmeldingen er tilstede i flere grener), vil du kanskje bruke:
git filter-branch -f --msg-filter \
'sed "s /  /  / g"' - --all
Git vil opprette en midlertidig katalog for omskriving og i tillegg sikkerhetskopiere gamle referanser i ref / original /.
-f vil håndheve utførelsen av operasjonen. Dette er nødvendig hvis den midlertidige katalogen allerede er tilstede, eller hvis det allerede er referanser lagret under referanser / original. Hvis det ikke er tilfelle, kan du slippe dette flagget.
- skiller filterfilialalternativer fra revisjonsalternativer.
--all vil sørge for at alle grener og tagger blir omskrevet.
På grunn av sikkerhetskopien av de gamle referansene, kan du enkelt gå tilbake til staten før du utfører kommandoen.
Si, du vil gjenopprette mesteren din og få tilgang til den i grenen old_master:
git checkout -b old_master refs / original / refs / heads / master
|
Bruk
git commit --endre
For å forstå det i detalj er et utmerket innlegg 4. Omskriving av Git History. Den snakker også om når du ikke skal bruke git commit - endre.
|
Hvis det er din siste forpliktelse, er det bare å endre forpliktelsen:
git commit --amend -o -m "New commit message"
(Bruk -o (--only) -flagget for å sikre at du bare endrer kommisjonsmeldingen)
Hvis det er en begravd begåelse, bruk den fantastiske interaktive rebasen:
git rebase -i @ ~ 9 # Vis de siste 9 forpliktelsene i en tekstredigerer
Finn forpliktelsen du ønsker, endre valg til r (omformuler), og lagre og lukk filen. Ferdig!
Miniatyr Vim-opplæring (eller hvordan du baserer på nytt med bare 8 tastetrykk 3jcwrEscZZ):
Kjør vimtutor hvis du har tid
hjkl tilsvarer bevegelsestaster ← ↓ ↑ →
Alle kommandoer kan være prefikset med et "område", f.eks. 3j beveger seg nedover tre linjer
i for å gå inn i innsettingsmodus - tekst du skriver vises i filen
Esc eller Ctrlc for å avslutte innsettingsmodus og gå tilbake til "normal" modus
u å angre
Ctrlr for å gjøre om
dd, dw, dl for å slette henholdsvis en linje, et ord eller en bokstav
cc, cw, cl for å endre henholdsvis en linje, et ord eller en bokstav (samme som ddi)
yy, yw, yl for å kopiere ("yank") en linje, et ord eller en bokstav
p eller P for å lime inn henholdsvis etter eller før gjeldende posisjon
: wEnter for å lagre (skrive) en fil
: q! Gå inn for å avslutte uten å lagre
: wqEnter eller ZZ for å lagre og avslutte
Hvis du redigerer tekst mye, bytter du til Dvorak-tastaturoppsettet, lærer å berøre og lærer Vim. Er det verdt innsatsen? Ja.
ProTip ™: Ikke vær redd for å eksperimentere med "farlige" kommandoer som omskriver historie * - Git sletter ikke forpliktelsene dine i 90 dager som standard; du finner dem i reflogen:
$ git reset @ ~ 3 # Gå tilbake tre forpliktelser
$ git reflog
c4f708b HEAD @ {0}: reset: flytter til @ ~ 3
2c52489 HEAD @ {1}: commit: flere endringer
4a5246d HEAD @ {2}: commit: gjør viktige endringer
e8571e4 HEAD @ {3}: commit: gjør noen endringer
... tidligere forplikter ...
$ git reset 2c52489
... og du er tilbake der du startet
* Se opp for alternativer som - hardt og - force skjønt - de kan forkaste data.
* Ikke skriv om historien på noen grener du samarbeider om.
|
Endre
Du har et paralternativene her. Du kan gjøre
git commit --endre
så lenge det er din siste forpliktelse.
Interaktiv rebase
Ellers, hvis det ikke er din siste forpliktelse, kan du gjøre en interaktiv rebase,
git rebase -i [branched_from] [hash before commit]
Så inne i den interaktive rebasen legger du ganske enkelt til redigering av den forpliktelsen. Når det kommer opp, gjør du en git-forpliktelse - endre og modifiser forpliktelsesmeldingen. Hvis du vil rulle tilbake før det forpliktelsespunktet, kan du også bruke git reflog og bare slette det forpliktelsen. Så gjør du bare en git-forpliktelse igjen.
|
Hvis du bruker Git GUI, kan du endre den siste forpliktelsen som ikke er presset med:
Forplikt / Endre siste forpliktelse
|
Jeg bruker Git GUI så mye jeg kan, og det gir deg muligheten til å endre den siste forpliktelsen:
Også, git rebase -i origin / master er et fint mantra som alltid vil presentere deg forpliktelsene du har gjort på toppen av master, og gi deg muligheten til å endre, slette, omorganisere eller squash. Du trenger ikke å få tak i den hasjen først.
|
Wow, så det er mange måter å gjøre dette på.
Nok en måte å gjøre dette på er å slette den siste forpliktelsen, men behold endringene slik at du ikke mister arbeidet ditt. Du kan deretter gjøre en annen forpliktelse med den korrigerte meldingen. Dette vil se ut slik:
git reset - soft HEAD ~ 1
git commit -m 'Ny og korrigert forpliktelsesmelding'
Jeg gjør alltid dette hvis jeg glemmer å legge til en fil eller gjøre en endring.
Husk å spesifisere --soft i stedet for --hard, ellers mister du den forpliktelsen helt.
|
For alle som leter etter en Windows / Mac GUI for å hjelpe med redigering av eldre meldinger (dvs. ikke bare den siste meldingen), vil jeg anbefale Sourcetree. Fremgangsmåten som skal følges er under bildet.
For forpliktelser som ikke har blitt presset til en fjernkontroll ennå:
Forsikre deg om at du har begått eller skjult alle gjeldende endringer (dvs. at det ikke er noen filer oppført i kategorien "Filstatus") - det fungerer ikke ellers.
I kategorien "Logg / historikk" høyreklikker du på oppføringen med en tilstøtende linje i grafen under forpliktelsen (e) du vil redigere, og velger "Rebase barn av  interaktivt ..."
Velg hele raden for en meldingsmelding du vil endre (klikk på kolonnen "Melding").
Klikk på "Rediger melding" -knappen.
Rediger meldingen som ønsket i dialogboksen som kommer opp, og klikk deretter OK.
Gjenta trinn 3-4 hvis det er andre forpliktende meldinger å endre.
Klikk OK: Rebasing starter. Hvis alt er bra, slutter utgangen "Fullført vellykket". MERK: Jeg har noen ganger sett dette mislykkes med Unable to create 'project_path / .git / index.lock': Filen eksisterer. når du prøver å endre flere meldinger samtidig. Ikke helt nøyaktig hva problemet er, eller om det vil bli løst i en fremtidig versjon av Sourcetree, men hvis dette skjer, vil du anbefale å omstille dem en om gangen (tregere, men virker mer pålitelig).
... Eller ... for forpliktelser som allerede er blitt presset:
Følg trinnene i dette svaret, som ligner på ovenfor, men krever at en annen kommando kjøres fra kommandolinjen (git push origin  -f) for å tvinge skyve grenen. Jeg vil anbefale å lese det hele og ta nødvendig forsiktighet!
|
Hvis du bare vil redigere den siste forpliktelsen, bruk:
git commit --endre
eller
git commit --end -m 'one line message'
Men hvis du vil redigere flere forpliktelser på rad, bør du bruke omstart i stedet:
git rebase -i 
I en fil, som den ovenfor, skriv edit / e eller et av de andre alternativene, og trykk på lagre og avslutt.
Nå vil du være på den første feil begåelsen. Gjør endringer i filene, så blir de automatisk iscenesatt for deg. Type
git commit --endre
Lagre og avslutt det og skriv
git rebase - fortsett
for å gå til neste valg til du er ferdig med alle valgene dine.
Vær oppmerksom på at disse tingene endrer alle SHA-hashene dine etter den aktuelle forpliktelsen.
|
Hvis du bare vil endre den siste meldingen din, bør du bruke - bare flagget eller snarveien til det -o med commit --endre:
git commit --amend -o -m "New commit message"
Dette sikrer at du ikke ved et uhell forbedrer forpliktelsen din med iscenesatte ting. Selvfølgelig er det best å ha en skikkelig $ EDITOR-konfigurasjon. Deretter kan du la alternativet -m være ute, og Git vil forhåndsutfylle forpliktelsesmeldingen med den gamle. På denne måten kan den enkelt redigeres.
|
Oppdater den siste feilmeldingsmeldingen din med den nye meldingsmeldingen i en linje:
git commit --amend -m "your new commit message"
Eller prøv Git reset som nedenfor:
# Du kan tilbakestille hodet til n antall forpliktelser
# IKKE en god ide for å endre den siste meldingen,
# men du kan få en idé om å dele oppdrag i flere forpliktelser
git reset - soft HEAD ^
# Det vil tilbakestille den siste forpliktelsen. Nå du
# kan forplikte den på nytt med ny forpliktelsesmelding.
Bruk reset for å dele forplikter til mindre forpliktelser
git reset kan hjelpe deg med å dele en forpliktelse i flere forpliktelser også:
# Tilbakestill hodet. Jeg tilbakestiller til siste forpliktelse:
git reset - soft HEAD ^
# (Du kan tilbakestille flere forpliktelser ved å gjøre HEAD ~ 2 (antall forpliktelser)
# Nå nullstill hodet ditt fordele den til flere forpliktelser
git reset HEAD
# Legg til og forplikt filene dine separat for å gjøre flere forpliktelser: f.eks
git legg til app /
git commit -m "legg til alle filer i appkatalogen"
git add config /
git commit -m "legg til alle filer i config-katalogen"
Her har du med hell brutt din siste forpliktelse i to forpliktelser.
|
På dette spørsmålet er det mange svar, men ingen av dem forklarer i detalj hvordan man kan endre eldre meldinger ved hjelp av Vim. Jeg satt fast og prøvde å gjøre dette selv, så her vil jeg skrive ned i detalj hvordan jeg gjorde dette spesielt for folk som ikke har noen erfaring i Vim!
Jeg ønsket å endre mine fem siste forpliktelser som jeg allerede presset til serveren. Dette er ganske 'farlig' fordi hvis noen andre allerede har trukket seg fra dette, kan du ødelegge ting ved å endre kommisjonsmeldingene. Når du jobber med din egen lille gren og er sikker på at ingen har trukket den, kan du endre den slik:
La oss si at du vil endre de fem siste forpliktelsene dine, og deretter skriver du dette i terminalen:
git rebase -i HEAD ~ 5
* Hvor 5 er antall kommisjonsmeldinger du vil endre (så hvis du vil endre den tiende til siste kommisjonen, skriver du inn 10).
Denne kommandoen vil føre deg inn i Vim der du kan 'redigere' forpliktelseshistorikken din. Du ser de fem siste forpliktelsene dine på toppen slik:
velg  commit-melding
I stedet for å velge må du skrive omformulering. Du kan gjøre dette i Vim ved å skrive i. Det får deg til å sette inn modus. (Du ser at du er i innsettingsmodus med ordet INSERT nederst.) For forpliktelsene du vil endre, skriv inn omformulering i stedet for å velge.
Da må du lagre og avslutte dette skjermbildet. Du gjør det ved først å gå inn i ‘kommandomodus’ ved å trykke på Esc-knappen (du kan sjekke at du er i kommandomodus hvis ordet INSERT nederst har forsvunnet). Deretter kan du skrive inn en kommando ved å skrive:. Kommandoen for å lagre og avslutte er wq. Så hvis du skriver inn: wq, er du på rett spor.
Deretter vil Vim gå gjennom alle kommisjonsmeldinger du vil omformulere, og her kan du faktisk endre kommisjonsmeldingene. Du gjør dette ved å gå inn i innsettingsmodus, endre kommittemeldingen, gå inn i kommandomodus og lagre og avslutte. Gjør dette fem ganger, så er du ute av Vim!
Så, hvis du allerede har presset feil forpliktelser, må du git push - force for å overskrive dem. Husk at git push --force er ganske farlig å gjøre, så sørg for at ingen trakk fra serveren siden du presset feil forpliktelser!
Nå har du endret kommisjonsmeldingene dine!
(Som du ser er jeg ikke så erfaren i Vim, så hvis jeg brukte feil 'lingo' for å forklare hva som skjer, kan du rette meg!)
|
Du kan bruke git-rebase-reword
Den er designet for å redigere ethvert commit (ikke bare sist) på samme måte som commit --amend
$ git rebase-reword 
Den er oppkalt etter handlingen på interaktiv rebase for å endre en forpliktelse: "reword". Se dette innlegget og interaksjonell modus for menneskeseksjonen-
Eksempler:
$ git rebase-reword b68f560
$ git rebase-reword HEAD ^
|
Jeg har lagt til aliasene reci og recm for å på nytt (endre) det. Nå kan jeg gjøre det med git recm eller git recm -m:
$ vim ~ / .gitconfig
[alias]
......
cm = begå
reci = forplikte - endre
recm = forplikte - endre
......
|
Jeg skjønte at jeg hadde presset en kommisjon med en skrivefeil i den. For å angre gjorde jeg følgende:
git commit --end -m "T-1000, avansert prototype"
git push --force
Advarsel: tvangsendring av endringene vil overskrive den eksterne grenen med den lokale. Forsikre deg om at du ikke overskriver noe du vil beholde. Vær også forsiktig med å tvinge frem en endret (omskrevet) forpliktelse hvis noen andre deler filialen med deg, fordi de trenger å skrive om sin egen historie hvis de har den gamle kopien av forpliktelsen du nettopp har skrevet om.
|
Jeg liker å bruke følgende:
git status
git add - alt
git commit -am "meldingen går her om endringen"
git pull 
git push 
|
Hvis du ikke har presset koden til den eksterne grenen (GitHub / Bitbucket), kan du endre kommittemeldingen på kommandolinjen som nedenfor.
git commit --endre -m "Din nye melding"
Hvis du jobber med en bestemt gren, gjør du dette:
git commit --end -m "BRANCH-NAME: new message"
Hvis du allerede har presset koden med feil melding, og du må være forsiktig når du endrer meldingen. Det vil si at når du endrer kommittemeldingen og prøver å presse den igjen, får du problemer. Følg disse trinnene for å gjøre det glatt.
Les hele svaret før du gjør det.
git commit --end -m "BRANCH-NAME: your new message"
git push -f origin BRANCH-NAME # Ikke en god praksis. Les nedenfor hvorfor?
Viktig merknad: Når du bruker krafttrykket direkte, kan det hende du får kodeproblemer som andre utviklere jobber med samme gren. Så for å unngå disse konfliktene, må du trekke koden fra grenen din før du gjør styrkentrykk:
git commit --end -m "BRANCH-NAME: your new message"
git pull origin BRANCH-NAME
git push -f origin BRANCH-NAME
Dette er den beste fremgangsmåten når du endrer kommisjonsmeldingen, hvis den allerede ble presset.
|
Er ikke svaret du leter etter? Bla gjennom andre spørsmål merket git git-commit git-rewrite-history endre eller still ditt eget spørsmål.